#include "../include/head.h"

// 双向链表的创建
f_list *init_double_link_list()
{
    f_list *list = (f_list *)malloc(sizeof(f_list));
    if (NULL == list)
    {
        ERRLOG("双向链表创建失败\n");
        return NULL;
    }
    list->next = NULL;
    return list;
}

// 双向链表的插入
void insert_double_node(f_list *list, f_data data, int pos)
{
    if (NULL == list)
    {
        ERRLOG("双向链表为空\n");
        return;
    }
    f_node *new_node = (f_node *)malloc(sizeof(f_node));
    if (NULL == new_node)
    {
        ERRLOG("节点创建失败\n");
        return;
    }
    new_node->data = data;
    new_node->next = new_node;
    new_node->prev = new_node;
    // 1.头插法
    if (pos == 1 || list->next == NULL)
    {
        if (list->next == NULL)
        {
            list->next = new_node;
            return;
        }
        if (1 == pos && NULL != list->next)
        {
            f_node *ptr = list->next;
            new_node->next = ptr;
            new_node->prev = ptr->prev;
            ptr->prev->next = new_node;
            ptr->prev = new_node;
            list->next = new_node;
            return;
        }
    }
    // 2.任意位置插入

    f_node *ptr = list->next;

    for (size_t i = 1; i < pos - 1; i++)
    {
        ptr = ptr->next;
    }

    // 开始插入
    // 1、 新结点的 next 指向 ptr的next
    new_node->next = ptr->next;
    // 2、 ptr next prev 指向 新结点
    ptr->next->prev = new_node;
    // 3、 新结点 prev 指向 ptr
    new_node->prev = ptr;
    // 4、 ptr next 指向 new_node
    ptr->next = new_node;
}

// 双向链表的删除
f_data delete_double_node(f_list *list, int pos)
{
    f_data data;
    // 安全判断
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return data ;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 为 NULL");
        return data ; 
    }

    // 删除
    f_node *ptr_1 = list->next;
    f_node *ptr_2 = ptr_1->next;

    // 头删  情况 1、 pos == 1  2、只有一个元素  ptr_1->next == list->nexts
    if (1 == pos || ptr_1->next == list->next)
    {
        // 只有一个结点数据的时候
        if (ptr_1->next == list->next)
        {
            data = ptr_1->data;
            free(list->next);
            list->next = NULL;
            return data;
        }
        // 多个结点数据删第一个
        if (1 == pos)
        {
            // 1、 将头结点 指向 第二个 结点
            list->next = ptr_2;
            // 2、 将 ptr2 指向 尾结点
            ptr_2->prev = ptr_1->prev;
            // 3、 将尾结点 的 指向 第二个结点
            ptr_1->prev->next = ptr_2;
            // 4、 保存 ptr_1 的数据
            data = ptr_1->data;
            // 5、 释放 ptr 1
            free(ptr_1);
            return data;
        }
    }
    f_node *ptr1 = list->next;
    f_node *ptr2 = ptr1->next;
     // 任意位置插和尾插
        for (size_t i = 1; i < pos - 1; i++)
        {
            ptr1 = ptr1->next;
        }
        ptr2 = ptr1->next;
        ptr1->next = ptr2->next;
        ptr2->next->prev = ptr1;
        data = ptr2->data;
        free(ptr2);
        return data;
}
// 双向链表的查找按班次
f_node *find_double_node_id(f_list *list, int id)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 为 NULL");
        return NULL;
    }
    f_node *ptr = list->next;
    while (ptr != list->next)
    {
        if (ptr->data.id == id)
        {
            printf("查找成功\n");
            return ptr;
        }
        ptr = ptr->next;
    }
    printf("查找失败\n");
    return NULL;
}

// 双向链表的查找按航班类型
f_node *find_double_node_flighttype(f_list *list, char *flighttype)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return NULL;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 为 NULL");
        return NULL;
    }
    f_node *ptr = list->next;
    while (ptr != list->next)
    {
        if (0 == strcmp(ptr->data.flighttype, flighttype))
        {
            printf("查找成功\n");
            return ptr;
        }
        ptr = ptr->next;
    }
    printf("查找失败\n");
    return NULL;
}

// 双向链表的遍历
void print_forward_double_link_list(f_list *list)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 无 数据");
        return;
    }

    f_node *ptr = list->next;
    printf("班次\t机型\t\t起点站\t终点站\t  起飞时间\t到达时间 飞行时间  票价\t  载客量 剩余座位 是否起飞\n");

    do
    {
        printf("%-8d", ptr->data.id);                                            // 航班班次
        printf("%-16s", ptr->data.flighttype);                                   // 飞机机型
        printf("%-12s", ptr->data.startcity);                                    // 航班起点站
        printf("%-12s", ptr->data.arrivecity);                                   // 航班终点站
        printf("%02d:%02d\t", ptr->data.starttime[0], ptr->data.starttime[1]);   // 起飞时间
        printf("%02d:%02d\t", ptr->data.arrivetime[0], ptr->data.arrivetime[1]); // 到达时间
        printf("  %-10s", ptr->data.flytime);                                    // 飞行时间
        printf("  %-8d", ptr->data.value);                                       // 票价
        printf("%-8d", ptr->data.maxNUM);                                        // 额定载客量
        printf("%-10d", ptr->data.leftbuyersa);                                  // 剩余座位数量
        printf("%c\n", ptr->data.whetherfly);
        ptr = ptr->next;
    } while (list->next != ptr);
}

//双向链表的清空
void clear_double_link_list(f_list* list)
{
    if (NULL == list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return ;
    }
    if (NULL == list->next)
    {
        ERRLOG("双向循环链表 为 NULL");
        return ;
    }
    f_node *ptr1 = list->next;
    f_node *ptr2 = ptr1->next;
    do
    {
        free(ptr1);
        ptr1 = ptr2;
        if (NULL != ptr2)
        {
            ptr2 = ptr2->next;
        }
    }while (ptr1 != list->next);
}

// 双向链表的销毁
void free_double_link_list(f_list **list)
{
    if (NULL == *list)
    {
        ERRLOG("双向循环链表 为 NULL");
        return ;
    }
    if (NULL == (*list)->next)
    {
        ERRLOG("双向循环链表 为 NULL");
        free(*list);
        *list = NULL;
        return ;
    }
    f_node *ptr1 = (*list)->next;
    f_node *ptr2 = ptr1->next;
    do
    {
        free(ptr1);
        ptr1 = ptr2;
        if (NULL != ptr2)
        {
            ptr2 = ptr2->next;
        }

    } while (ptr1 != (*list)->next);
}


